package com.otherTest.java8;

import com.mongodb.entity.User;
import org.junit.Test;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Created by Administrator on 2017/6/7 0007.
 */
public class TestStream {


    @Test
    public void Streamtest() {
        List<String> stringList = new ArrayList<>();
        stringList.add("1");
        stringList.add("2");
        stringList.add("3");
        stringList.add("4");
        stringList.add("5");
        stringList.add("6");
        stringList.add("7");
        stringList.add("8");
        stringList.add("9");
        stringList.add("10");
        //并行流 list中元素等于1的单独放置入新list 并赋值给新List
        List<String> result=stringList.stream().filter(x -> (x.equals(new String("1")))).collect(Collectors.toList());
        result.forEach(System.out::println);
        //返回大于2的元素 并进行相加
        int sum= stringList.stream().filter(
                (String x) -> Integer.parseInt(x) <= new Integer(2)
        )
                .mapToInt((x) -> Integer.parseInt(x))
                .sum();
        //.count();
        System.out.print(sum);
    }
        @Test
        public void Stream() throws ParseException {
        //格式化时间
        DateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //String按照限定格式转换为时间
        Date date1=sdf.parse("1992-06-14 07:00:00");
        //System.out.println(date1);//Sun Jun 14 07:00:00 CST 1992
        //Date 按照格式转换为string
        String date2=sdf.format(date1);
        //System.out.println(date2);//1992-06-14 07:00:00
        List<com.mongodb.entity.User> userList=new ArrayList<>();
        userList.add(new com.mongodb.entity.User("1","赵航","809411396@qq.com","man",sdf.parse("1992-06-14 07:00:00")));
        userList.add(new com.mongodb.entity.User("2","习近平","习近平@qq.com","man",sdf.parse("1953-06-11 07:00:00")));
        userList.add(new com.mongodb.entity.User("3","大桥未久","おおはしみく@qq.com","woman",sdf.parse("1987-12-14 07:00:00")));
        userList.add(new com.mongodb.entity.User("4","坂本龙马","さかもと  りょうま@qq.com","man",sdf.parse("1836-01-3 07:00:00")));
        userList.add(new com.mongodb.entity.User("5","刘德华","Andy Lau@qq.com","man",sdf.parse("1961-09-27 07:00:00")));
        userList.add(new com.mongodb.entity.User("6","周星驰","9527@qq.com","man",sdf.parse("1962-06-22 07:00:00")));
        userList.add(new com.mongodb.entity.User("7","周杰伦","9527@qq.com","man",sdf.parse("1979-01-18 07:00:00")));


        //stream 常用方法 不常用的一些方法没有使用 以及测试
        /**
         * anyMatch
         * 返回此流的所有元素是否与提供的谓词匹配。
         * @see 此流中是否有user元素的id大于5
         * @return boolean
         * @exception 抛出的异常 无
         */
        boolean anyMatch=userList.stream().anyMatch(u -> (Integer.parseInt(u.getUserId())<5));
        //System.out.println(anyMatch);
        /**
         * allMatch
         * 返回此流的全部元素是否与提供的谓词匹配
         * @see 此流中是否全部的id大于5
         * @return boolean
         * @exception 抛出的异常 无
         * */
        boolean allMatch=userList.stream().allMatch(u -> (Integer.parseInt(u.getUserId())<5));
        //System.out.println(allMatch);
        /**
         * count
         * 返回此流中的元素总数
         * @return long
         * @exception 抛出的异常 无
         */
        long count=userList.stream().count();
        //System.out.println(count);

        /**
         * distinct
         * 返回由该流的不同元素(根据 Object.equals(Object))组成的流
         * @see 去重逻辑依赖元素的equals方法 应为每个List对象中都为new 所以去重没有效果
         * @return Stream<T>
         * @exception 抛出的异常 无
         */
        userList.stream().distinct();
        //userList.stream().forEach(user -> System.out.println(user.getUserName()));
        /**
         * filter
         * 返回由与此给定谓词匹配的此流的元素组成的流
         * @see 过滤器 给定自定义条件进行过滤 本类中将list中用户名的长度为3的元素单独放入一个Stream
         * @return Stream<T>
         * @exception 抛出的异常 无
         */
        Stream<com.mongodb.entity.User>userStream=userList.stream().filter(user -> user.getUserName().length()==3);
        //userStream.forEach(user -> System.out.println(user.getUserName()));
        /**
         * findAny()
         * 返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional
         * @see 返回流中的元素,找到任何一个就行 list为有序则为下标为1的元素,如果流中没有元素则返回一个空的Optional对象 也可以加入filter限定之后返回任意一个满足田间的元素
         * @return 返回Optional<T>
         * @exception 抛出的异常 nullPointException
         */
        Optional<com.mongodb.entity.User>userOptionalAny=userList.stream().findAny();
        //System.out.println(userOptionalAny.get().getUserName());

        /**
         * findFirst()
         * 返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional
         * @see 返回遇到第一个元素 list为有序则为下标为1的元素,如果流中没有元素则返回一个空的Optional对象
         * @return Optional<T>
         * @exception 抛出的异常 nullPointException
         */
        Optional<com.mongodb.entity.User>userOptionalFirst=userList.stream().findFirst();
        //System.out.println(userOptionalFirst.get().getUserName());

        /**
         * flatmap
         * 返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流
         * @see 将Stream中的元素按照自定义格式 映射分割成为新Stream 比如将userList中的每个元素的 email字段用@分开 映射成为新的Stream对象
         * 输入stream的每一个元素，map的输出对应一个元素，必然是一个元素（null也是要返回），flatmap是0或者多个元素（为null的时候其实就是0个元素）。
         * flatmap的意义在于，一般的java方法都是返回一个结果，但是对于结果数量不确定的时候，用map这种java方法的方式，是不太灵活的，所以引入了flatmap。
         * 对于Optional的map和flatmap：map是把结果自动封装成一个Optional，但是flatmap需要你自己去封装
         * @return <R> Stream<R>
         * @exception 抛出的异常 无
         */
        Stream<String > stringStream=userList.stream().flatMap(user ->
                        Stream.of(user.getEmail().split("@"))
        );
        //stringStream.forEach(System.out::println);
        //可以直接对映射之后的元素直接打包为StringList 并直接打印
        //userList.stream().flatMap(user -> Stream.of(user.getEmail())).collect(Collectors.toList()).forEach(System.out::println);
        /**
         * flatMapToDouble
         *返回一个 DoubleStream ，其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
         * @see 相关主题
         * @return DoubleStream
         * @exception 抛出的异常
         */
        // userList.stream().flatMap();
        //flatMapToDouble(user -> Stream.of(Double.parseDouble("1")));
        /**
         * flatMapToInt
         * @param 所需形参
         * @see 相关主题
         * @return IntStream
         * @exception 抛出的异常
         */
        /**
         * flatMapToLong
         * @param 所需形参
         * @see 相关主题
         * @return LongStream
         * @exception 抛出的异常
         */

        /**
         * max
         * 根据提供的 Comparator返回此流的最大元素。
         * @see 相关主题
         * @return Optional<T>
         * @exception 抛出的异常   nullPointException
         */

        OptionalInt sum=userList.stream().mapToInt((x) -> Integer.parseInt(x.getUserId())).max();
        //System.out.println(sum.getAsInt());
        //int sum=userList.stream().flatMapToInt((x) -> Integer.parseInt(x.getUserId())).sum();

        /**
         * min
         * 根据提供的 Comparator返回此流的最小元素。
         * @see 相关主题
         * @return Optional<T>
         * @exception 抛出的异常 nullPointException
         */


        userList.stream()
                .sorted(Comparator.comparing(User::getUserId).thenComparing(User::getUserName))
                .forEach(System.out::println);
    }


}



